/*exercice 2*/

est_un_mot(_).

inserer(X,L,[X|L]).
inserer(X,[Y|L],[Y|R]):-inserer(X,L,R).

perm([],[]).
perm([X|L],R):-perm(L,T),inserer(X,T,R).

anagrammes(L,R):-perm(L,R),est_un_mot(R).

sous_liste([],[]).
sous_liste([X|L],R):- sous_liste(L,T), (R=T;R=[X|T]).

tous_les_mots(L,R):-sous_liste(L,T),anagramme(T,R),est_un_mot(R).


/* exercice 3: positions encodees par des listes
de longueur 4,  representant le bloc en  position [1,1]
[1,2],[2,1] et [2,2], respectivement.
Les listes  contiennent les termes 1,2,3,vide. */


move([vide,X,Y,Z],[X,vide,Y,Z]).
move([vide,X,Y,Z],[Y,X,vide,Z]).
move([X,vide,Y,Z],[X,Z,Y,vide]).
move([X,vide,Y,Z],[vide,X,Y,Z]).
move([X,Y,vide,Z],[vide,Y,X,Z]).
move([X,Y,vide,Z],[X,Y,Z,vide]).
move([X,Y,Z,vide],[X,Y,vide,Z]).
move([X,Y,Z,vide],[X,vide,Z,Y]).

member(X,[X|_]):-!.
member(X,[_|Y]):-member(X,Y).

finale([1,2,3,vide]).

peut_terminer_aux(X,_):- finale(X),!.
peut_terminer_aux(X,V):-move(X,Y), not(member(Y,V)),peut_terminer_aux(Y,[Y|V]).


peut_terminer(X):-peut_terminer_aux(X,[]).


/*exercice 4*/

somme([],0).
somme([X|L],R):-somme(L,T),R is X+T.

somme_acc([],A,A).
somme_acc([X|L],A,R):-B is X+A, somme_acc(L,B,R).


produit([],1).
produit([X|L],R):-produit(L,T),R is X*T.

produit_acc([],A,A).
produit_acc([X|L],A,R):-B is X*A, produit_acc(L,B,R).

iterer([],P,B,B).
iterer([X|L],P,B,R):- T=..[P,X,B,Z],T,iterer(L,P,Z,R).